* handles launching an application in a graphical context. It provides
* startup notification and allows to launch applications on a specific
* screen or workspace.
- * <example>
- * <title>Launching an application</title>
+ *
+ * ## Launching an application
+ *
* |[<!-- language="C" -->
* GdkAppLaunchContext *context;
*
*
* g_object_unref (context);
* ]|
- * </example>
*/
* be controlling each of these virtual devices. Physical devices may also
* be "floating", which means they are not attached to any virtual device.
*
- * <example><title>Master and slave devices</title>
+ * ## Master and slave devices
+ *
* <screen>
* carlos@sacarino:~$ xinput list
* ⎡ Virtual core pointer id=2 [master pointer (3)]
* ↳ AT Translated Set 2 keyboard id=12 [slave keyboard (3)]
* ↳ ThinkPad Extra Buttons id=15 [slave keyboard (3)]
* </screen>
- * </example>
*
* By default, GDK will automatically listen for events coming from all
* master devices, setting the #GdkDevice for all events coming from input
* You can use gdk_x11_display_error_trap_push() to ignore errors
* on only a single display.
*
-* <example>
- * <title>Trapping an X error</title>
+ * ## Trapping an X error
+ *
* |[<!-- language="C" -->
* gdk_error_trap_push (<!-- -->);
*
* // ... Handle the error here ...
* }
* ]|
- * </example>
*/
void
gdk_error_trap_push (void)
* you are building your application against. At runtime, use type-check
* macros like GDK_IS_X11_DISPLAY() to find out which backend is in use:
*
- * <example id="backend-specific">
- * <title>Backend-specific code</title>
+ * ## Backend-specific code ## {#backend-specific}
+ *
* |[<!-- language="C" -->
* #ifdef GDK_WINDOWING_X11
* if (GDK_IS_X11_DISPLAY (display))
* #endif
* g_error ("Unsupported GDK backend");
* ]|
- * </example>
*/
*
* Rendering a Pango layout is done most simply with pango_cairo_show_layout();
* you can also draw pieces of the layout with pango_cairo_show_layout_line().
- * <example id="rotated-example">
- * <title>Draw transformed text with Pango and cairo</title>
+ *
+ * ## Draw transformed text with Pango and cairo ## {#rotated-example}
+ *
* <!-- Note that this example is basically the same as
* demos/gtk-demo/rotated_text.c -->
* |[<!-- language="C" -->
* g_object_unref (layout);
* g_object_unref (context);
* ]|
- * </example>
+ *
* <figure>
* <title>Output of <xref linkend="rotated-example"/></title>
* <graphic fileref="rotated-text.png" format="PNG"/>
* set (see #GtkAccelFlags).
* A #GtkAccelLabel can display multiple accelerators and even signal names,
* though it is almost always used to display just one accelerator key.
- * <example>
- * <title>Creating a simple menu item with an accelerator key.</title>
+ *
+ * ## Creating a simple menu item with an accelerator key.
+ *
* |[<!-- language="C" -->
* GtkWidget *save_item;
* GtkAccelGroup *accel_group;
* gtk_widget_add_accelerator (save_item, "activate", accel_group,
* GDK_KEY_s, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
* ]|
- * </example>
*/
enum {
* <graphic fileref="bloatpad-xfce.png" format="PNG"/>
* </figure>
*
- * <example id="gtkapplication"><title>A simple application</title>
+ * ## A simple application ## {#gtkapplication}
+ *
* |[<!-- language="C" -->
* <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../examples/bloatpad.c">
* <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
* </xi:include>
* ]|
- * </example>
*
* GtkApplication optionally registers with a session manager
* of the users session (if you set the #GtkApplication:register-session
* also be shown as part of client-side window decorations, e.g. by
* using gtk_header_bar_set_show_close_button().
*
- * <example><title>A GtkApplicationWindow with a menubar</title>
+ * ## A GtkApplicationWindow with a menubar
+ *
* |[<!-- language="C" -->
* app = gtk_application_new ();
*
*
* window = gtk_application_window_new (app);
* ]|
- * </example>
*
- * <example><title>Handling fallback yourself</title>
+ * ## Handling fallback yourself
+ *
* |[<!-- language="C" -->
* <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../examples/sunny.c">
* <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
* background color before sending the expose event, and that
* drawing is implicitly clipped to the exposed area.
*
- * <example>
- * <title>Simple GtkDrawingArea usage</title>
+ * ## Simple GtkDrawingArea usage
+ *
* |[<!-- language="C" -->
* gboolean
* draw_callback (GtkWidget *widget, cairo_t *cr, gpointer data)
* g_signal_connect (G_OBJECT (drawing_area), "draw",
* G_CALLBACK (draw_callback), NULL);
* ]|
- * </example>
*
* Draw signals are normally delivered when a drawing area first comes
* onscreen, or when it's covered by another window and then uncovered.
* the following handler to #GtkEditable::insert-text, an application
* can convert all entry into a widget into uppercase.
*
- * <example>
- * <title>Forcing entry to uppercase.</title>
+ * ## Forcing entry to uppercase.
+ *
* |[<!-- language="C" -->
* #include <ctype.h>;
*
* g_free (result);
* }
* ]|
- * </example>
*/
#include "config.h"
* dialog should be used, it should return
* %GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM. The following example
* illustrates this.
- * <example id="gtkfilechooser-confirmation">
- * <title>Custom confirmation</title>
+ *
+ * ## Custom confirmation ## {#gtkfilechooser-confirmation}
+ *
* |[<!-- language="C" -->
* static GtkFileChooserConfirmation
* confirm_overwrite_callback (GtkFileChooser *chooser, gpointer data)
*
* gtk_widget_destroy (chooser);
* ]|
- * </example>
*
* Returns: a #GtkFileChooserConfirmation value that indicates which
* action to take after emitting the signal.
* that button. This widget does not support setting the
* #GtkFileChooser:select-multiple property to %TRUE.
*
- * <example>
- * <title>Create a button to let the user select a file in /etc</title>
+ * ## Create a button to let the user select a file in /etc
+ *
* |[<!-- language="C" -->
* {
* GtkWidget *button;
* "/etc");
* }
* ]|
- * </example>
*
* The #GtkFileChooserButton supports the #GtkFileChooserAction<!-- -->s
* %GTK_FILE_CHOOSER_ACTION_OPEN and %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
* own. Instead, you should use the functions that work on a
* #GtkFileChooser.
*
- * <example id="gtkfilechooser-typical-usage">
- * <title>Typical usage</title>
+ * ## Typical usage ## {#gtkfilechooser-typical-usage}
+ *
* In the simplest of cases, you can the following code to use
* #GtkFileChooserDialog to select a file for opening:
- * <para>
+ *
* |[
* GtkWidget *dialog;
*
*
* gtk_widget_destroy (dialog);
* ]|
- * </para>
+ *
* To use a dialog for saving, you can use this:
- * <para>
+ *
* |[
* GtkWidget *dialog;
*
*
* gtk_widget_destroy (dialog);
* ]|
- * </para>
- * </example>
*
- * ## Setting up a file chooser dialog
+ * ## Setting up a file chooser dialog ## {#gtkfilechooserdialog-setting-up}
*
- * <para id="gtkfilechooserdialog-setting-up">
* There are various cases in which you may need to use a #GtkFileChooserDialog:
- * </para>
*
* - To select a file for opening. Use #GTK_FILE_CHOOSER_ACTION_OPEN.
*
* i.e. when you are doing a Save As command and you already
* have a file saved somewhere.
- * ## Response Codes
+ * ## Response Codes ## {#gtkfilechooserdialog-responses}
*
- * <para id="gtkfilechooserdialog-response-codes">
* #GtkFileChooserDialog inherits from #GtkDialog, so buttons that
* go in its action area have response codes such as
* #GTK_RESPONSE_ACCEPT and #GTK_RESPONSE_CANCEL. For example, you
* could call gtk_file_chooser_dialog_new() as follows:
+ *
* |[
* GtkWidget *dialog;
*
* _("_Open"), GTK_RESPONSE_ACCEPT,
* NULL);
* ]|
- * </para>
*
- * <para id="gtkfilechooserdialog-responses">
* This will create buttons for "Cancel" and "Open" that use stock
* response identifiers from #GtkResponseType. For most dialog
* boxes you can use your own custom response codes rather than the
* ones in #GtkResponseType, but #GtkFileChooserDialog assumes that
* its "accept"-type action, e.g. an "Open" or "Save" button,
* will have one of the following response codes:
- * </para>
+ *
* - #GTK_RESPONSE_ACCEPT
* - #GTK_RESPONSE_OK
* - #GTK_RESPONSE_YES
* so by default does not receive events. If you want to receive events
* on the image, such as button clicks, place the image inside a
* #GtkEventBox, then connect to the event signals on the event box.
- * <example>
- * <title>Handling button press events on a #GtkImage.</title>
+ *
+ * ## Handling button press events on a #GtkImage.
+ *
* |[<!-- language="C" -->
* static gboolean
* button_press_callback (GtkWidget *event_box,
* return image;
* }
* ]|
- * </example>
*
* When handling events on the event box, keep in mind that coordinates
* in the image may be different from event box coordinates due to
* by default on the level bar: #GTK_LEVEL_BAR_OFFSET_LOW and
* #GTK_LEVEL_BAR_OFFSET_HIGH, with values 0.25 and 0.75 respectively.
*
- * <example>
- * <title>Adding a custom offset on the bar</title>
+ * ## Adding a custom offset on the bar
+ *
* |[<!-- language="C" -->
*
* static GtkWidget *
* return level_bar;
* }
* ]|
- * </example>
*
* The default interval of values is between zero and one, but it's possible to
* modify the interval using gtk_level_bar_set_min_value() and
* #GtkFileChooserDialog. After a callback finishes, GTK+ will return to the
* main loop and await more user input.
*
- * <example>
- * <title>Typical main() function for a GTK+ application</title>
+ * ## Typical main() function for a GTK+ application
+ *
* |[<!-- language="C" -->
* int
* main (int argc, char **argv)
* return 0;
* }
* ]|
- * </example>
*
* It's OK to use the GLib main loop directly instead of gtk_main(), though it
* involves slightly more typing. See #GMainLoop in the GLib documentation.
* This can be used to update the UI and invoke timeouts etc.
* while doing some time intensive computation.
*
- * <example>
- * <title>Updating the UI during a long computation</title>
+ * ## Updating the UI during a long computation
+ *
* |[<!-- language="C" -->
* /* computation going on... */
*
*
* /* ...computation continued */
* ]|
- * </example>
*
* Returns: %TRUE if any events are pending, %FALSE otherwise
*/
* of a window. Of course you should not do this as the user expects
* a reaction from clicking the close icon of the window...
*
- * <example>
- * <title>A persistent window</title>
+ * ## A persistent window
+ *
* |[<!-- language="C" -->
* #include <gtk/gtk.h>
*
* return 0;
* }
* ]|
- * </example>
*
* Returns: %TRUE
*/
* gtk_menu_popup() function. The example below shows how an application
* can pop up a menu when the 3rd mouse button is pressed.
*
- * <example>
- * <title>Connecting the popup signal handler.</title>
+ * ## Connecting the popup signal handler.
+ *
* |[<!-- language="C" -->
* /<!---->* connect our handler which will popup the menu *<!---->/
* g_signal_connect_swapped (window, "button_press_event",
* G_CALLBACK (my_popup_handler), menu);
* ]|
- * </example>
*
- * <example>
- * <title>Signal handler which displays a popup menu.</title>
+ * ## Signal handler which displays a popup menu.
+ *
* |[<!-- language="C" -->
* static gint
* my_popup_handler (GtkWidget *widget, GdkEvent *event)
* return TRUE;
* }
* }
- *
+ *
* return FALSE;
* }
* ]|
- * </example>
*/
#include "config.h"
* or use gtk_print_run_page_setup_dialog() to show the page setup dialog
* and receive the resulting page setup.
*
- * <example>
- * <title>A page setup dialog</title>
+ * ## A page setup dialog
+ *
* |[<!-- language="C" -->
* static GtkPrintSettings *settings = NULL;
* static GtkPageSetup *page_setup = NULL;
* page_setup = new_page_setup;
* }
* ]|
- * </example>
*
* Printing support was added in GTK+ 2.10.
*/
* The application can set the position of the slider as if it were set
* by the user, by calling gtk_paned_set_position().
*
- * <example>
- * <title>Creating a paned widget with minimum sizes.</title>
+ * ## Creating a paned widget with minimum sizes.
+ *
* |[<!-- language="C" -->
* GtkWidget *hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
* GtkWidget *frame1 = gtk_frame_new (NULL);
* gtk_paned_pack2 (GTK_PANED (hpaned), frame2, FALSE, FALSE);
* gtk_widget_set_size_request (frame2, 50, -1);
* ]|
- * </example>
*/
enum {
* #GtkPrintOperation::end-print, #GtkPrintOperation::request-page-setup and
* #GtkPrintOperation::draw-page signals on the #GtkPrintOperation.
*
- * <example>
- * <title>Using GtkPrintContext in a #GtkPrintOperation::draw-page callback</title>
+ * ## Using GtkPrintContext in a #GtkPrintOperation::draw-page callback
+ *
* |[<!-- language="C" -->
* static void
* draw_page (GtkPrintOperation *operation,
* g_object_unref (layout);
* }
* ]|
- * </example>
*
* Printing support was added in GTK+ 2.10.
*/
* #GtkPrintOperation::draw-page, which you are supposed to catch
* and render the page on the provided #GtkPrintContext using Cairo.
*
- * <example>
- * <title>The high-level printing API</title>
+ * ## The high-level printing API
+ *
* |[<!-- language="C" -->
* static GtkPrintSettings *settings = NULL;
*
* g_object_unref (print);
* }
* ]|
- * </example>
*
* By default GtkPrintOperation uses an external application to do
* print preview. To implement a custom print preview, an application
* The group list does not need to be freed, as each #GtkRadioButton will remove
* itself and its list item when it is destroyed.
*
- * <example>
- * <title>How to create a group of two radio buttons.</title>
+ * ## How to create a group of two radio buttons.
+ *
* |[<!-- language="C" -->
* void create_radio_buttons (void) {
*
* return;
* }
* ]|
- * </example>
*
* When an unselected button in the group is clicked the clicked button
* receives the #GtkToggleButton::toggled signal, as does the previously
* The correct way to create a group of radio menu items is approximatively
* this:
*
- * <example>
- * <title>How to create a group of radio menu items.</title>
+ * ## How to create a group of radio menu items.
+ *
* |[<!-- language="C" -->
* GSList *group = NULL;
* GtkWidget *item;
* gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), TRUE);
* }
* ]|
- * </example>
*/
-
struct _GtkRadioMenuItemPrivate
{
GSList *group;
* Note that #GtkRecentChooserDialog does not have any methods of its own.
* Instead, you should use the functions that work on a #GtkRecentChooser.
*
- * <example id="gtkrecentchooser-typical-usage">
- * <title>Typical usage</title>
+ * ## Typical usage ## {#gtkrecentchooser-typical-usage}
+ *
* In the simplest of cases, you can use the following code to use
* a #GtkRecentChooserDialog to select a recently used file:
+ *
* |[<!-- language="C" -->
* GtkWidget *dialog;
*
*
* gtk_widget_destroy (dialog);
* ]|
- * </example>
*
* Recently used files are supported since GTK+ 2.10.
*/
* The following example shows you how to create a more complex search
* entry.
*
- * <example>
- * <title>Creating a search bar</title>
+ * ## Creating a search bar
+ *
* |[<!-- language="C" -->
* <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../examples/search-bar.c">
* <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
* </xi:include>
* ]|
- * </example>
*
* Since: 3.10
*/
* gtk_search_bar_connect_entry(), this function will return
* immediately with a warning.
*
- * <example>
- * <title>Showing the search bar on key presses</title>
+ * ## Showing the search bar on key presses
+ *
* |[<!-- language="C" -->
* static gboolean
* window_key_press_event_cb (GtkWidget *widget,
* g_signal_connect (window, "key-press-event",
* G_CALLBACK (window_key_press_event_cb), search_bar);
* ]|
- * </example>
*
* Return value: %GDK_EVENT_STOP if the key press event resulted
* in text being entered in the search entry (and revealing
* Before using this function, the socket must have been realized,
* and for hence, have been added to its parent.
*
- * <example>
- * <title>Obtaining the window ID of a socket.</title>
+ * ## Obtaining the window ID of a socket.
+ *
* |[<!-- language="C" -->
* GtkWidget *socket = gtk_socket_new (<!-- -->);
* gtk_widget_show (socket);
* g_print ("The ID of the sockets window is %#x\n",
* gtk_socket_get_id (socket));
* ]|
- * </example>
*
* Note that if you pass the window ID of the socket to another
* process that will create a plug in the socket, you must make
* See the #GtkAdjustment section for more details about an adjustment's
* properties.
*
- * <example>
- * <title>Using a GtkSpinButton to get an integer</title>
+ * ## Using a GtkSpinButton to get an integer
+ *
* |[<!-- language="C" -->
* /* Provides a function to retrieve an integer value from a
* * GtkSpinButton and creates a spin button to model percentage
* gtk_widget_show_all (window);
* }
* ]|
- * </example>
*
- * <example>
- * <title>Using a GtkSpinButton to get a floating point value</title>
+ * ## Using a GtkSpinButton to get a floating point value
+ *
* |[<!-- language="C" -->
* /* Provides a function to retrieve a floating point value from a
* * GtkSpinButton, and creates a high precision spin button.
* gtk_widget_show_all (window);
* }
* ]|
- * </example>
*/
struct _GtkSpinButtonPrivate
* on or off, and %GTK_STATE_FLAG_INCONSISTENT determines whether it
* should be marked as undefined.
*
- * <example>
- * <title>Typical checkmark rendering</title>
+ * Typical checkmark rendering:
+ *
* 
- * </example>
*
* Since: 3.0
**/
* state will determine whether the option is on or off, and
* %GTK_STATE_FLAG_INCONSISTENT whether it should be marked as undefined.
*
- * <example>
- * <title>Typical option mark rendering</title>
+ * Typical option mark rendering:
+ *
* 
- * </example>
*
* Since: 3.0
**/
*
* Renders an arrow pointing to @angle.
*
- * <example>
- * <title>Typical arrow rendering at 0, 1&solidus;2 π, π and 3&solidus;2 π</title>
+ * Typical arrow rendering at 0, 1&solidus;2 π, π and 3&solidus;2 π:
+ *
* 
- * </example>
*
* Since: 3.0
**/
*
* Renders the background of an element.
*
- * <example>
- * <title>Typical background rendering, showing the effect of
+ * Typical background rendering, showing the effect of
* <parameter>background-image</parameter>,
* <parameter>border-width</parameter> and
- * <parameter>border-radius</parameter></title>
+ * <parameter>border-radius</parameter>:
+ *
* 
- * </example>
*
* Since: 3.0.
**/
*
* Renders a frame around the rectangle defined by @x, @y, @width, @height.
*
- * <example>
- * <title>Examples of frame rendering, showing the effect of
+ * Examples of frame rendering, showing the effect of
* <parameter>border-image</parameter>,
* <parameter>border-color</parameter>,
* <parameter>border-width</parameter>,
- * <parameter>border-radius</parameter> and
- * junctions</title>
+ * <parameter>border-radius</parameter> and junctions:
+ *
* 
- * </example>
*
* Since: 3.0
**/
* defined by @x, @y, @width, @height. The state %GTK_STATE_FLAG_ACTIVE
* determines whether the expander is collapsed or expanded.
*
- * <example>
- * <title>Typical expander rendering</title>
+ * Typical expander rendering:
+ *
* 
- * </example>
*
* Since: 3.0
**/
* @height: rectangle height
*
* Renders a focus indicator on the rectangle determined by @x, @y, @width, @height.
- * <example>
- * <title>Typical focus rendering</title>
+ *
+ * Typical focus rendering:
+ *
* 
- * </example>
*
* Since: 3.0
**/
* @width, @height. @orientation defines whether the slider is vertical
* or horizontal.
*
- * <example>
- * <title>Typical slider rendering</title>
+ * Typical slider rendering:
+ *
* 
- * </example>
*
* Since: 3.0
**/
* for %GTK_POS_TOP and %GTK_POS_BOTTOM gap sides, and Y coordinates for
* %GTK_POS_LEFT and %GTK_POS_RIGHT.
*
- * <example>
- * <title>Typical rendering of a frame with a gap</title>
+ * Typical rendering of a frame with a gap:
+ *
* 
- * </example>
*
* Since: 3.0
**/
* defined by @x, @y, @width, @height. The side where the extension
* connects to is defined by @gap_side.
*
- * <example>
- * <title>Typical extension rendering</title>
+ * Typical extension rendering:
+ *
* 
- * </example>
*
* Since: 3.0
**/
* #GtkWindow<!-- -->'s resize grip), in the rectangle
* determined by @x, @y, @width, @height.
*
- * <example>
- * <title>Handles rendered for the paned and grip classes</title>
+ * Handles rendered for the paned and grip classes:
+ *
* 
- * </example>
*
* Since: 3.0
**/
*
* To simply switch the state of a toggle button, use gtk_toggle_button_toggled().
*
- * <example>
- * <title>Creating two #GtkToggleButton widgets.</title>
+ * ## Creating two #GtkToggleButton widgets.
+ *
* |[<!-- language="C" -->
* void make_toggles (void) {
* GtkWidget *dialog, *toggle1, *toggle2;
* gtk_widget_show_all (dialog);
* }
* ]|
- * </example>
*/
* easier, the second is much more common, as you often get paths from
* callbacks.
*
- * <example>
- * <title>Acquiring a #GtkTreeIter-struct</title>
+ * ## Acquiring a #GtkTreeIter-struct
+ *
* |[<!-- language="C" -->
* /* Three ways of getting the iter pointing to the location */
* GtkTreePath *path;
* parent_iter = iter;
* gtk_tree_model_iter_nth_child (model, &iter, &parent_iter, 5);
* ]|
- * </example>
*
* This second example shows a quick way of iterating through a list
* and getting a string and an integer from each row. The
* shown, as it is specific to the #GtkListStore. For information on
* how to write such a function, see the #GtkListStore documentation.
*
- * <example>
- * <title>Reading data from a #GtkTreeModel</title>
+ * ## Reading data from a #GtkTreeModel
+ *
* |[<!-- language="C" -->
* enum
* {
* row_count++;
* }
* ]|
- * </example>
*
* The #GtkTreeModel interface contains two methods for reference
* counting: gtk_tree_model_ref_node() and gtk_tree_model_unref_node().
* simply put the same model in each widget, then sorting the first would
* sort the second.
*
- * <example>
- * <title>Using a #GtkTreeModelSort</title>
+ * ## Using a #GtkTreeModelSort
+ *
* |[<!-- language="C" -->
* {
* GtkTreeView *tree_view1;
* COLUMN_1, GTK_SORT_DESCENDING);
* }
* ]|
- * </example>
*
* To demonstrate how to access the underlying child model from the sort
* model, the next example will be a callback for the #GtkTreeSelection
* from COLUMN_1 of the model. We then modify the string, find the same
* selected row on the child model, and change the row there.
*
- * <example>
- * <title>Accessing the child model of in a selection changed callback</title>
+ * ## Accessing the child model of in a selection changed callback
+ *
* |[<!-- language="C" -->
* void
* selection_changed (GtkTreeSelection *selection, gpointer data)
* g_free (modified_data);
* }
* ]|
- * </example>
*/
* updated on widget hierarchy changes.
*
* The widget path generation is generally simple:
- * <example>
- * <title>Defining a button within a window</title>
+ *
+ * ## Defining a button within a window
+ *
* |[<!-- language="C" -->
* {
* GtkWidgetPath *path;
* gtk_widget_path_append_type (path, GTK_TYPE_BUTTON);
* }
* ]|
- * </example>
*
* Although more complex information, such as widget names, or
* different classes (property that may be used by other widget
* types) and intermediate regions may be included:
*
- * <example>
- * <title>Defining the first tab widget in a notebook</title>
+ * ## Defining the first tab widget in a notebook
+ *
* |[<!-- language="C" -->
* {
* GtkWidgetPath *path;
* gtk_widget_path_iter_set_name (path, pos, "first tab label");
* }
* ]|
- * </example>
*
* All this information will be used to match the style information
* that applies to the described widget.
projects / gtk4.git / commitdiff